package cn.nr19.jian.`object`

import cn.nr19.jian.J2Utils
import cn.nr19.jian.Jian
import cn.nr19.jian.eon
import cn.nr19.jian.`object`.annotation.JianFun
import cn.nr19.jian.token.ARRNode
import cn.nr19.jian.token.BooleanNode
import cn.nr19.jian.token.ENode
import cn.nr19.jian.token.EONNode
import cn.nr19.jian.token.NULL
import cn.nr19.jian.token.Node
import cn.nr19.jian.token.NumNode
import cn.nr19.jian.token.StrNode

open class ARR : ArrayList<Any>, JianObject {
    constructor()

    /**
     * 节点 取绝对值。 编辑器 -> 运行转变
     */
    constructor(ls : ARRNode){
        inin(ls)
    }
    constructor(string: String){
        inin(ARRNode(string))
    }
    fun inin(ls : ARRNode){
        ls.datas.forEach {
            when(it.nodeType()){
                ENode.str -> add((it as StrNode).value)
                ENode.num-> add((it as NumNode).value)
                ENode.boolean -> add((it as BooleanNode).value)
                ENode.arr -> add(ARR(it as ARRNode))
                ENode.eon -> add(EON(it as EONNode))
                else -> {
                    add(it)
                }
            }
        }
    }
    override fun pFun(data: JianLeiApi,name: String, pars: List<Any>): Any? {
        return when(name){
            "加入" -> {
                for (par in pars) {
                    add(par)
                }
                return true
            }
            "插入" -> {
                if (pars.size > 1 && pars[0] is Int){
                    var i = pars[0] as Int
                    pars.forEach {
                        add(i,it)
                        i++ // 后面加入的放在这个后面
                    }
                }
                return true
            }
            else -> {
                super.pFun(data,name, pars)
            }
        }
    }

    @JianFun("参数1=位置:整数：；返回=键对应的数据")
    open fun 取(p : Int) : Any{
        if (p >= 0 && p < size) return get(p)
        else return NULL()
    }

    @JianFun("参数1=位置:整数：；返回=键对应的数据")
    open fun 读(k : Int) : Any{
        return 取(k)
    }

    @JianFun("返回=项目数()和成员数() 返回的结果一致，均为成员数量。")
    open fun 项目数() : Int {
        return size
    }

    @JianFun("返回=项目数()和成员数() 返回的结果一致，均为成员数量。")
    open fun 成员数() : Int {
        return size
    }

    @JianFun("返回=输出文本。")
    open fun 到文本() : String {
        return toString()
    }

    @JianFun("删除指定成员； 参数1=位置：整数")
    open fun 删除(k : Int) : Boolean{
        return remove(k)
    }

    @JianFun("删除所有成员")
    open fun 清空() : Boolean{
        clear()
        return true
    }

    @JianFun("合并为字符串;参数1:字符串=成员之间的分界符号")
    open fun 合并(k : String) : String{
        if (size == 0) return ""
        StringBuilder().let {str->

            forEach {
                str.append(it.toString()).append(k)
            }

            // 去尾符k
            if (size > 1 && k.isNotEmpty()){
                str.delete(str.length - k.length,k.length)
            }

            return toString()
        }
    }


    override fun toString(): String {
        StringBuilder().apply {
            append("[")

            this@ARR.forEach {
                append(J2Utils.toString(it)).append(",")
            }
            if (length > 1) {
                deleteCharAt(length - 1)
            }

            append("]")
            return toString()
        }
    }

}